home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Taifun / Taifun 054 (1988-05-15)(Ossowski, Stefan)(DE)(PD).zip / Taifun 054 (1988-05-15)(Ossowski, Stefan)(DE)(PD).adf / MRBackup / MRBackup2.0 / Console.c < prev    next >
C/C++ Source or Header  |  1988-04-09  |  3KB  |  162 lines
  1. /* MRBackup Console Routines
  2.  * Filename:    Console.c
  3.  * Date:        11/22/87
  4.  *
  5.  * Console I/O Routines from Rob Peck's "Programmer's Guide to the Amiga".
  6.  */
  7.  
  8. #include "MRBackup.h"
  9.  
  10. ConIOBlocks *
  11. CreateConsole(window)
  12.     struct Window *window;
  13. {
  14.     ConIOBlocks *c;
  15.     struct MsgPort *tpw;
  16.  
  17.     if (!(c = AllocMem((long) sizeof(ConIOBlocks), 
  18.                         MEMF_CLEAR | MEMF_PUBLIC)))
  19.         goto cleanup1;
  20.  
  21.     if (!(tpw = CreatePort(0L, 0L)))
  22.         goto cleanup2;
  23.  
  24.     if (!(c->tpr = CreatePort(0L, 0L)))
  25.         goto cleanup3;
  26.  
  27.     if (!(c->writeReq = CreateStdIO(tpw)))
  28.         goto cleanup4;
  29.  
  30.     if (!(c->readReq = CreateStdIO(c->tpr)))
  31.         goto cleanup5;
  32.  
  33.     c->writeReq->io_Data = (APTR)window;
  34.     c->writeReq->io_Length = sizeof(struct Window);
  35.  
  36.     if (OpenDevice("console.device", 0L, c->writeReq, 0L))
  37.         goto cleanup6;
  38.  
  39.     /* Read and write are both talking to the same instance of a console. */
  40.     c->readReq->io_Device = c->writeReq->io_Device;
  41.     c->readReq->io_Unit   = c->writeReq->io_Unit;
  42.     return c;
  43.  
  44. cleanup6:
  45.     DeleteStdIO(c->readReq);
  46. cleanup5:
  47.     DeletePort(c->tpr);
  48. cleanup4:
  49.     DeleteStdIO(c->writeReq);
  50. cleanup3:
  51.     DeletePort(tpw);
  52. cleanup2:
  53.     FreeMem(c, (long) sizeof(ConIOBlocks));
  54. cleanup1:
  55.     return NULL;
  56. }
  57.  
  58. int
  59. DeleteConsole(c)
  60.     ConIOBlocks *c;
  61. {
  62.     struct MsgPort *mp;
  63.  
  64.     AbortIO(c->readReq);        /* abort any read in progress */
  65.     CloseDevice(c->writeReq);    /* close the console device */
  66.  
  67.     mp = c->writeReq->io_Message.mn_ReplyPort;
  68.  
  69.     DeleteStdIO(c->writeReq);
  70.     DeletePort(mp);
  71.  
  72.     mp = c->readReq->io_Message.mn_ReplyPort;
  73.  
  74.     DeleteStdIO(c->readReq);
  75.     DeletePort(mp);
  76.  
  77.     FreeMem(c, (long) sizeof(ConIOBlocks));
  78.     return 0;
  79. }
  80.  
  81. #define CONREAD c->readReq
  82. #define CONWRITE c->writeReq
  83.  
  84. void
  85. EnqueueRead(c, location)
  86.     ConIOBlocks *c; char *location;
  87. {
  88.     struct IOStdReq *conr;
  89.  
  90.     conr = CONREAD;
  91.     conr->io_Command = CMD_READ;
  92.     conr->io_Length = 1;
  93.     conr->io_Data = (APTR) location;
  94.     SendIO(conr);                /* asynchronous read request */
  95. }
  96.  
  97. /* Write a specified number of characters from a buffer to a particular
  98.  * console device. 
  99.  */
  100.  
  101. void
  102. ConWrite(c, data, length)
  103.     ConIOBlocks *c; char *data; WORD length;
  104. {
  105.     struct IOStdReq *conw;
  106.  
  107.     if (length == 0) length = strlen(data);
  108.     conw = CONWRITE;
  109.     conw->io_Command = CMD_WRITE;
  110.     conw->io_Length = length;
  111.     conw->io_Data = (APTR) data;
  112.     DoIO(conw);                    /* synchronous write request */
  113. }
  114.  
  115. /* Get a character from the console, with optional wait.
  116.  * Called with:
  117.  *        c:        console control structure
  118.  *        wait:    0 => asynchronous read (no wait)
  119.  *                1 => synchronous read (wait)
  120.  * Returns:
  121.  *        character or -1 (async and no character)
  122.  */
  123. int
  124. CGetCharacter(c, wait)
  125.     ConIOBlocks *c; BOOL wait;
  126. {
  127.     struct MsgPort *mp;
  128.     struct IOStdReq *conr;
  129.     char *dataAddr;
  130.     int temp;
  131.  
  132.     mp = c->tpr;
  133.     if (wait) {
  134.         WaitPort(mp);
  135.     }
  136.     conr = (struct IOStdReq *) GetMsg(mp);
  137.     if (conr == NULL)
  138.         return -1;
  139.     else {
  140.         dataAddr = (char *)conr->io_Data;
  141.         temp = *dataAddr;            /* get the value */
  142.         EnqueueRead(c, dataAddr);    /* continue the read */
  143.         return temp;
  144.     }
  145. }
  146.  
  147. #ifdef DEBUG
  148. DebugWrite(msg)
  149.     char *msg;
  150. {
  151.     ConWrite(debugConsole, msg, strlen(msg));
  152. }
  153. #endif
  154.  
  155. /* Write string to progress window. */
  156.  
  157. WriteConsole(msg)
  158.     char *msg;
  159. {
  160.     ConWrite(progressConsole, msg, strlen(msg));
  161. }
  162.